home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 483 / mkrscsrc / menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-04-29  |  11.8 KB  |  492 lines
  1. #include "stdio.h"
  2. #include "gemdefs.h"
  3. #include "obdefs.h"
  4. #include "osbind.h"
  5. #include "mkrsc.h"
  6. #include "globals.h"
  7.  
  8. /*
  9.     do_menu - determines which menu was selected and calls the
  10.         appropriate routine to handle the item selected.
  11. */
  12. do_menu(message)
  13.     int *message;
  14. {
  15.     int menuid, itemid;
  16.  
  17.     menuid = message[3];
  18.     itemid = message[4];
  19.  
  20.     switch(menuid) {
  21.         case DESK:        handle_desk(itemid);
  22.                         break;
  23.         case FILE:        handle_file(itemid);
  24.                         break;
  25.         case EDIT:        handle_edit(itemid);
  26.                         break;
  27.         case CHOOSE:     handle_choose(itemid);
  28.                            break;
  29.         case WINDOWS:    handle_rot();
  30.                         break;
  31.     }
  32.  
  33.     menu_tnormal(mkrscmnu, menuid, 1);
  34. }
  35.  
  36.  
  37. int handle_rot()
  38. {
  39.     int i;
  40.     OBJECT *inwinptr;
  41.  
  42.  
  43.             inwinptr = thefrontwin->inwindow->objt;
  44.             for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  45.             if(inwinptr[i].ob_state & SELECTED)
  46.                 inwinptr[i].ob_state &= ~SELECTED;
  47.  
  48.             rot_wind();
  49. }
  50.  
  51. int handle_desk(itemid)
  52.     int itemid;
  53. {
  54.     switch(itemid) {
  55.         case    ABOUT    :
  56.                             aboutt[AOK].ob_state = NORMAL;
  57.                             do_dialog(aboutt,0);
  58.                             break;
  59.                     }    
  60.  
  61. }
  62.  
  63. handle_file(itemid)
  64.     int itemid;
  65. {
  66.     windowptr thewin;
  67.     OBJECT *inwinptr;
  68.     int i, button, abort, len;
  69.  
  70.     abort = 0;
  71.     switch(itemid) {
  72.         case NEW:        if(thewin = new_window())
  73.                             open_window(thewin);
  74.                         break;
  75.         case OPEN:    if( (thefrontwin)
  76.                       && (thefrontwin->inwindow != &thefrontwin->maintree) )
  77.                     {    inwinptr = thefrontwin->inwindow->objt;
  78.                         for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  79.                         if(inwinptr[i].ob_state & SELECTED)
  80.                             inwinptr[i].ob_state &= ~SELECTED;
  81.                         thefrontwin->inwindow = &thefrontwin->maintree;
  82.                         draw_inwind(thefrontwin,1);
  83.                         draw_obj(treicont);
  84.                     }
  85.                         len = strlen(fs_inpath);
  86.                         for(i=len;i>0;i--)  /* find last occurrence of \  */
  87.                             if(fs_inpath[i] =='\\') break;
  88.                         fs_inpath[i+1] = 0;
  89.                         strcat(fs_inpath,"*.RSC");
  90.                         ret_rsc();    
  91.                         len = strlen(fs_inpath);
  92.                         for(i=len;i>0;i--)  /* find last occurrence of \  */
  93.                             if(fs_inpath[i] =='\\') break;
  94.                         fs_inpath[i+1] = 0;
  95.                         strcat(fs_inpath,"*.*");
  96.                         break;
  97.         case CLOSE:         if(thefrontwin)
  98.                     { if(thefrontwin->inwindow == &thefrontwin->maintree)
  99.         {
  100.             
  101.             {    button = 1;
  102.                 if(thefrontwin->saved != TRUE)
  103.                     button =  form_alert(1, "[2][ Save before closing? ][CLOSE|SAVE|CANCEL]");
  104.                 if (button == 3)
  105.                     break;
  106.                 else if (button == 2)
  107.                 {    if(getfile(thefrontwin))
  108.                         make_rsc();
  109.                         break;
  110.                 }
  111.                 else
  112.                     dispose_window(thefrontwin);
  113.             }
  114.         }
  115.                 else
  116.                     {    inwinptr = thefrontwin->inwindow->objt;
  117.                         for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  118.                         if(inwinptr[i].ob_state & SELECTED)
  119.                             inwinptr[i].ob_state &= ~SELECTED;
  120.                         if(thefrontwin->inwindow->kind[0] == TMENU)
  121.                             sort_boxes();
  122.                         thefrontwin->inwindow = &thefrontwin->maintree;
  123.  
  124.                         draw_inwind(thefrontwin,1);
  125.                         draw_obj(treicont);
  126.                     }
  127.                     }
  128.                         break;
  129.         case SAVEAS:
  130.             if(thefrontwin)
  131.                 {    if(thefrontwin->inwindow != &thefrontwin->maintree)
  132.                     {    inwinptr = thefrontwin->inwindow->objt;
  133.                         for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  134.                         if(inwinptr[i].ob_state & SELECTED)
  135.                             inwinptr[i].ob_state &= ~SELECTED;
  136.                         if(thefrontwin->inwindow->kind[0] == TMENU)
  137.                             sort_boxes();
  138.                         thefrontwin->inwindow = &thefrontwin->maintree;
  139.                         draw_inwind(thefrontwin,1);
  140.                         draw_obj(treicont);
  141.                     }
  142.                         if(getfile(thefrontwin))
  143.                             make_rsc();
  144.                 }
  145.                         break;
  146.         case SAVE:
  147.                 if(thefrontwin)
  148.                 {        if(thefrontwin->inwindow != &thefrontwin->maintree)
  149.                     {    inwinptr = thefrontwin->inwindow->objt;
  150.                         for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  151.                         if(inwinptr[i].ob_state & SELECTED)
  152.                             inwinptr[i].ob_state &= ~SELECTED;
  153.                         if(thefrontwin->inwindow->kind[0] == TMENU)
  154.                             sort_boxes();
  155.                         thefrontwin->inwindow = &thefrontwin->maintree;
  156.                         draw_inwind(thefrontwin,1);
  157.                         draw_obj(treicont);
  158.                     }
  159.                             make_rsc();
  160.                 }
  161.                         break;
  162.         case QUIT:
  163.         while(thefrontwin)
  164.         { if(thefrontwin->inwindow != &thefrontwin->maintree)
  165.                 {    inwinptr = thefrontwin->inwindow->objt;
  166.                     for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  167.                     if(inwinptr[i].ob_state & SELECTED)
  168.                         inwinptr[i].ob_state &= ~SELECTED;
  169.                     if(thefrontwin->inwindow->kind[0] == TMENU)
  170.                         sort_boxes();
  171.                     thefrontwin->inwindow = &thefrontwin->maintree;
  172.                     draw_inwind(thefrontwin,1);
  173.                     draw_obj(treicont);
  174.                 }
  175.                 button = 1;
  176.                 if(thefrontwin->saved != TRUE)
  177.                 button =  form_alert(1, "[2][ Save before closing? ][CLOSE|SAVE|CANCEL]");
  178.                 if (button == 3)
  179.                 {    abort = 1;
  180.                     break;
  181.                 }
  182.                 else if (button == 2)
  183.                 {    if(getfile(thefrontwin))
  184.                         make_rsc();
  185.                 }
  186.                 dispose_window(thefrontwin);
  187.         }
  188.         if(abort == 0)
  189.             shutdown(0);
  190.         break;
  191.     }
  192. }
  193.  
  194. int handle_edit(itemid)
  195.     int itemid;
  196. {
  197.     switch(itemid)    {
  198.         case ERASE    :     if(thefrontwin)
  199.                         { if(thefrontwin->inwindow != &thefrontwin->maintree)
  200.                             erase_obj();
  201.                           else
  202.                             erase_tree();
  203.                         }
  204.                         break;
  205.         case COPY     :
  206.             if(thefrontwin)
  207.             {    if(thefrontwin->inwindow == &thefrontwin->maintree)
  208.                 {    if(tempm)
  209.                     {    free(tempm->treelink[0]);
  210.                         free(tempm);
  211.                     }
  212.                     tempm = copy_tree(1);
  213.                 }
  214.                 else
  215.                     copy_obj(1);
  216.             }
  217.                         break;
  218.         case PASTE    :
  219.             if(thefrontwin)
  220.             {    if ( (thefrontwin->inwindow == &thefrontwin->maintree) 
  221.                         && (tempm) )
  222.                         paste_tree(tempm);
  223.                 else
  224.                     paste_obj();
  225.                     draw_inwind(thefrontwin,0);
  226.             }
  227.             break;
  228.         case CUT    :    
  229.             if(thefrontwin)
  230.             {    if(thefrontwin->inwindow == &thefrontwin->maintree)
  231.                     {    if(tempm)
  232.                         {    free(tempm->treelink[0]);
  233.                             free(tempm);
  234.                         }
  235.                         tempm = copy_tree(0);
  236.                         erase_tree();
  237.                     }
  238.                     else
  239.                     {    copy_obj(0);
  240.                         erase_obj();
  241.                     }
  242.             }
  243.                         break;
  244.                     }
  245. }
  246.  
  247.  
  248. int handle_choose(itemid)
  249.     int itemid;
  250. {
  251.     OBJECT *inwinptr;
  252.     int i, button;
  253.  
  254.     switch(itemid)    {
  255.         case NAM    :     if(thefrontwin)
  256.                         {    name_obj();
  257.                         inwinptr = thefrontwin->inwindow->objt;
  258.                         for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  259.                         if(inwinptr[i].ob_state & SELECTED)
  260.                         {    inwinptr[i].ob_state &= ~SELECTED;
  261.                             break;
  262.                         }
  263.                         draw_inwind(thefrontwin,0);
  264.                         }
  265.                         break;
  266.         case SNAP    :
  267.     if( (thefrontwin)
  268.                 && (thefrontwin->inwindow != &thefrontwin->maintree) )
  269.     {
  270.         if (snap)
  271.         {
  272.             button =  form_alert(1, "[0][ Unsnapped objects may be | positioned differently at | different resolutions. ][OK|CANCEL]");
  273.             if (button == 1)
  274.             {    strcpy(mkrscmnu[SNAP].ob_spec,"  Snap now OFF");
  275.                 mkrscmnu[SNAP].ob_state = NORMAL;
  276.                 snap = FALSE;        
  277.             }
  278.         }
  279.         else
  280.         {    strcpy(mkrscmnu[SNAP].ob_spec,"  Snap now ON");
  281.             mkrscmnu[SNAP].ob_state = CHECKED;
  282.             snap = TRUE;
  283.         }
  284.     }
  285.             break;
  286.             
  287.         case SALL    :
  288.         {    inwinptr = thefrontwin->inwindow->objt;
  289.                 for(i=1;i<(thefrontwin->inwindow->count + 1);i++)
  290.                 {    inwinptr[i].ob_x += gl_wchar/2;
  291.                     inwinptr[i].ob_x &= 0xFFF8;
  292.                     inwinptr[i].ob_y += gl_hchar/2;
  293.                     inwinptr[i].ob_y &= (0xFFFF - gl_hchar + 1);
  294.                     inwinptr[i].ob_width += gl_wchar/2;
  295.                     inwinptr[i].ob_width &= 0xFFF8;
  296.                     inwinptr[i].ob_height += gl_hchar/2;
  297.                     inwinptr[i].ob_height &= (0xFFFF - gl_hchar + 1);
  298.                 }
  299.                 draw_inwind(thefrontwin,1);
  300.         }
  301.             break;
  302.             
  303.         case SSEL    :
  304.             inwinptr = thefrontwin->inwindow->objt;
  305.             for(i=1;i<(thefrontwin->inwindow->count + 1);i++)
  306.             {    if(inwinptr[i].ob_state & SELECTED)
  307.                 {    inwinptr[i].ob_state &= ~SELECTED;
  308.                     inwinptr[i].ob_x += gl_wchar/2;
  309.                     inwinptr[i].ob_x &= 0xFFF8;
  310.                     inwinptr[i].ob_y += gl_hchar/2;
  311.                     inwinptr[i].ob_y &= (0xFFFF - gl_hchar + 1);
  312.                     inwinptr[i].ob_width += gl_wchar/2;
  313.                     inwinptr[i].ob_width &= 0xFFF8;
  314.                     inwinptr[i].ob_height += gl_hchar/2;
  315.                     inwinptr[i].ob_height &= (0xFFFF - gl_hchar + 1);
  316.                 }
  317.             }
  318.             draw_inwind(thefrontwin,1);
  319.             break;
  320.             
  321.         case SORT    :
  322.         if( (thefrontwin)
  323.                 && (thefrontwin->inwindow != &thefrontwin->maintree) )
  324.         {    inwinptr = thefrontwin->inwindow->objt;
  325.             for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  326.             if(inwinptr[i].ob_state & SELECTED)
  327.             {    do_sort();
  328.                 break;
  329.             }
  330.         }
  331.         draw_inwind(thefrontwin,0);
  332.         break;
  333.         case COUT    :    mkrscmnu[COUT].ob_state ^= CHECKED;
  334.                         cout ^= 1;
  335.                         break;
  336.                     }
  337. }
  338.  
  339. int do_sort()
  340. {
  341.     int button;
  342.  
  343.  
  344.     sortd[SRTOK].ob_state &= ~SELECTED;
  345.     sortd[SRTCAN].ob_state &= ~SELECTED;
  346.     sortd[SRTX].ob_state &= ~SELECTED;
  347.     sortd[SRTY].ob_state &= ~SELECTED;
  348.     sortd[SRTXY].ob_state &= ~SELECTED;
  349.     sortd[SRTYX].ob_state &= ~SELECTED;
  350.  
  351.     button = do_dialog(sortd,0);
  352.     switch (button)
  353.     {
  354.         case SRTCAN    :    return;
  355.                         break;
  356.         case SRTOK    :
  357.         if            (sortd[SRTX].ob_state &= SELECTED)
  358.             {    sort_x();
  359.                 break;
  360.             }    
  361.         else if        (sortd[SRTY].ob_state &= SELECTED)
  362.             {    sort_y();
  363.                 break;
  364.             }
  365.         else if        (sortd[SRTXY].ob_state &= SELECTED)
  366.             {    sort_x();
  367.                 sort_y();
  368.                 break;
  369.             }    
  370.         else if        (sortd[SRTYX].ob_state &= SELECTED)
  371.             {    sort_y();
  372.                 sort_x();
  373.                 break;
  374.             }
  375.         else break;    
  376.     }
  377. }
  378.  
  379. int sort_x()
  380. {
  381.     OBJECT *inwinptr;
  382.     int    i, numobjs, head, k, j, finished;
  383.     struct     {    int index;
  384.                 int ob_x;
  385.             } xorder[MAXONUM], temp;
  386.     
  387.     inwinptr = thefrontwin->inwindow->objt;
  388.     for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  389.     if(inwinptr[i].ob_state & SELECTED)
  390.     {        
  391.             inwinptr[i].ob_state &= ~SELECTED;
  392.             head = inwinptr[i].ob_head;
  393.             if (head < 1) break;
  394.             k = 0;
  395. /*    make an array of the children and their x values    */
  396.  
  397.             for(j=head;j != i;j=inwinptr[j].ob_next)
  398.             {    xorder[k].index = j;
  399.                 xorder[k++].ob_x = inwinptr[j].ob_x;
  400.             }
  401.             numobjs = k;
  402.             if(numobjs < 2) break;
  403. /*    sort the array according to x values    */
  404.             finished = FALSE;
  405.             while(!finished)
  406.             {    finished = TRUE;
  407.                 for(j = 0;j < numobjs-1; j++)
  408.                 if(xorder[j].ob_x > xorder[j+1].ob_x)
  409.                 {    temp = xorder[j];
  410.                     xorder[j] = xorder[j+1];
  411.                     xorder[j+1] = temp;
  412.                     finished = FALSE;
  413.                 }
  414.             }
  415. /*    remake the object tree    */
  416.             inwinptr[i].ob_head = xorder[0].index;
  417.             for(j=0;j<numobjs-1;j++)
  418.                 inwinptr[xorder[j].index].ob_next = xorder[j+1].index;
  419.             inwinptr[xorder[j].index].ob_next = i;
  420.             inwinptr[i].ob_tail = xorder[j].index;
  421.     }
  422. }
  423.  
  424. int sort_y()
  425. {
  426.     OBJECT *inwinptr;
  427.     int    i, numobjs, head, k, j, finished;
  428.     struct     {    int index;
  429.                 int ob_y;
  430.             } xorder[MAXONUM], temp;
  431.     
  432.     inwinptr = thefrontwin->inwindow->objt;
  433.     for(i=0;i<(thefrontwin->inwindow->count + 1);i++)
  434.     if(inwinptr[i].ob_state & SELECTED)
  435.     {        
  436.             inwinptr[i].ob_state &= ~SELECTED;
  437.             head = inwinptr[i].ob_head;
  438.             if (head < 1) break;
  439.             k = 0;
  440. /*    make an array of the children and their y values    */
  441.  
  442.             for(j=head;j != i;j=inwinptr[j].ob_next)
  443.             {    xorder[k].index = j;
  444.                 xorder[k++].ob_y = inwinptr[j].ob_y;
  445.             }
  446.             numobjs = k;
  447.             if(numobjs < 2) break;
  448. /*    sort the array according to x values    */
  449.             finished = FALSE;
  450.             while(!finished)
  451.             {    finished = TRUE;
  452.                 for(j = 0;j < numobjs-1; j++)
  453.                 if(xorder[j].ob_y > xorder[j+1].ob_y)
  454.                 {    temp = xorder[j];
  455.                     xorder[j] = xorder[j+1];
  456.                     xorder[j+1] = temp;
  457.                     finished = FALSE;
  458.                 }
  459.             }
  460. /*    remake the object tree    */
  461.             inwinptr[i].ob_head = xorder[0].index;
  462.             for(j=0;j<numobjs-1;j++)
  463.                 inwinptr[xorder[j].index].ob_next = xorder[j+1].index;
  464.             inwinptr[xorder[j].index].ob_next = i;
  465.             inwinptr[i].ob_tail = xorder[j].index;
  466.     }
  467. }
  468.  
  469. int sort_boxes()
  470. {
  471.     int    boxes[50], count;
  472.     int i, head, next, bparent;
  473.     OBJECT *tree;
  474.     objtreeptr thetree;
  475.  
  476.     thetree = thefrontwin->inwindow;
  477.     tree = thetree->objt;
  478.  
  479.     bparent = tree[1].ob_next;
  480.     head = tree[bparent].ob_head;
  481.     
  482.     boxes[0] = head;
  483.     for(next=head,i=1;(next!=bparent && i < 500);next=tree[next].ob_next,i++)
  484.         boxes[i] = tree[next].ob_next;
  485.  
  486.     count = i -1;
  487.     for(i = 1; i < count; i++)
  488.     {    tree[boxes[i]].ob_state |= SELECTED;
  489.         sort_y();
  490.     }
  491. }
  492.